package com.example.demoexample.utils;

import java.io.UnsupportedEncodingException;
import java.util.Locale;
import java.util.regex.Pattern;

public class StringUtil {

    /**
     * 用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。
     *
     * @param string
     * @param index  字符的索引
     * @return
     */
    public char charAt(String string, int index) {
        return string.charAt(index);
    }

    /**
     * 返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，
     * 如果第一个字符和参数的第一个字符不等，结束比较，
     * 返回他们之间的差值，如果第一个字符和参数的第一个字符相等，
     * 则以第二个字符和参数的第二个字符做比较，以此类推,直至比较的字符或被比较的字符有一方结束
     *
     * @param s1
     * @param s2
     * @return 如果参数字符串等于此字符串，则返回值 0；
     * 如果此字符串小于字符串参数，则返回一个小于 0 的值；
     * 如果此字符串大于字符串参数，则返回一个大于 0 的值
     */
    public int compareTo(String s1, String s2) {
        return s1.compareTo(s2);
    }

    /**
     * 用于按字典顺序比较两个字符串，不考虑大小写
     *
     * @param s1
     * @param s2
     * @return 与compareTo方法的区别是 不考虑大小写
     */
    public int compareToIgnoreCase(String s1, String s2) {
        return s1.compareToIgnoreCase(s2);
    }

    /**
     * 将指定的字符串参数连接到字符串上
     *
     * @param s1 要连接的字符串
     * @param s2
     * @return s1 + s2
     */
    public String concat(String s1, String s2) {
        return s1.concat(s2);
    }

    /**
     * 将此字符串与指定的 StringBuffer 比较
     *
     * @param s1
     * @param sb
     * @return 如字符串与指定 StringBuffer 表示相同的字符序列，则返回 true；否则返回 false
     */
    public boolean contentEquals(String s1, StringBuffer sb) {
        return s1.contentEquals(sb);
    }

    /**
     * 返回指定数组中表示该字符序列的字符串
     *
     * @param s1
     * @param data
     * @return
     */
    public static String copyValueOf(String s1, char[] data) {
        String s2 = "";
        s2 = s2.copyValueOf(data);
        return s2;
    }

    /**
     * 返回指定数组中表示该字符序列的 字符串
     *
     * @param s1
     * @param data   字符数组
     * @param offset 子数组的初始偏移量
     * @param count  子数组的长度
     * @return
     */
    public static String copyValueOf(String s1, char[] data, int offset, int count) {
        return s1.copyValueOf(data, offset, count);
    }

    /**
     * 测试字符串是否以指定的后缀结束
     *
     * @param s1
     * @param suffix
     * @return
     */
    public boolean endsWith(String s1, String suffix) {
        return s1.endsWith(suffix);
    }

    /**
     * 使用指定的字符集将字符串编码为 byte 序列，
     * 并将结果存储到一个新的 byte 数组中
     *
     * @param charsetName
     * @return
     * @throws UnsupportedEncodingException
     */
    public byte[] getBytes(String charsetName, String s2) throws UnsupportedEncodingException {
//        charsetName.getBytes("ISO-8859-1");
        charsetName.getBytes(s2);
        return charsetName.getBytes(s2);
    }

    /**
     * 使用平台的默认字符集将字符串编码为 byte 序列，
     * 并将结果存储到一个新的 byte 数组中。
     *
     * @return
     */
    public byte[] getBytes(String s1) {
        return s1.getBytes();
    }

    /**
     * 将字符从字符串复制到目标字符数组
     *
     * @param srcBegin 字符串中要复制的第一个字符的索引
     * @param srcEnd   字符串中要复制的最后一个字符之后的索引
     * @param dst      目标数组
     * @param dstBegin 目标数组中的起始偏移量
     */
    public char[] getChars(String str1, int srcBegin, int srcEnd, char[] dst, int dstBegin) {
        try {
            str1.getChars(srcBegin, srcEnd, dst, dstBegin);
        } catch (Exception e) {
            System.out.print("拷贝字符串触发异常");
        }

        return dst;
    }

    /**
     * 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
     *
     * @param ch Unicode 编码
     * @return
     */
    public int indexOf(int ch) {
        String string = "aaa456ac";
        return string.indexOf(ch);
    }

    /**
     * 从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
     *
     * @param ch
     * @param fromIndex 开始搜索的索引位置，第一个字符是 0 ，第二个是 1 ，以此类推
     * @return
     */
    public int indexOf(int ch, int fromIndex) {
        String string = "aaa456ac";
        return string.indexOf(ch, 3);
    }

    /**
     * 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
     *
     * @param str 要搜索的子字符串
     * @return
     */
    int indexOf(String str) {
        String string = "aaa456ac";
        return string.indexOf(str);
    }

    /**
     * 返回从 fromIndex 位置开始查找指定字符串在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
     *
     * @param str       要搜索的子字符串
     * @param fromIndex
     * @return
     */
    int indexOf(String str, int fromIndex) {
        String string = "aaa456ac";
        return string.indexOf(str, 3);
    }

    /**
     * 返回字符串对象的规范化表示形式。
     * 它遵循以下规则：对于任意两个字符串 s 和 t，
     * 当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true
     *
     * @return 一个字符串，内容与此字符串相同，但一定取自具有唯一字符串的池
     * 这个方法会首先检查字符串池中是否有这个字符串，如果存在则返回这个字符串的引用，否则就将这个字符串添加到字符串池中，然会返回这个字符串的引用
     */
    public String intern() {
        String str1 = "handler";  //在字符串池中
        String str2 = new String("object");  //不在字符串池中
        return str2.intern();
    }

    /**
     * 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
     *
     * @param ch ch -- 字符。
     * @return
     */
    public int lastIndexOf(int ch) {
        String str = new String("菜鸟教程:www.runoob.com");
        return str.lastIndexOf(ch);
    }

    /**
     * 如果此字符串中没有这样的字符，则返回 -1。
     *
     * @param ch
     * @param fromIndex 开始搜索的索引位置。
     * @return
     */
    public int lastIndexOf(int ch, int fromIndex) {
        String str = new String("菜鸟教程:www.runoob.com");
        return str.lastIndexOf(ch, fromIndex);
    }

    /**
     * 子字符串 最后出现的位置，如果没有，则返回 -1
     *
     * @param str 要搜索的子字符串
     * @return
     */
    public int lastIndexOf(String str) {
        String str2 = new String("菜鸟教程:www.runoob.com");
        return str2.lastIndexOf(str);
    }

    /**
     * 从第fromIndex个位置开始搜索子字符串 str最后出现的位置
     *
     * @param str
     * @param fromIndex
     * @return
     */
    public int lastIndexOf(String str, int fromIndex) {
        String str2 = new String("菜鸟教程:www.runoob.com");
        return str2.lastIndexOf(str, fromIndex);
    }

    /**
     * 用于检测字符串是否匹配给定的正则表达式
     *
     * @param regex -- 匹配字符串的正则表达式
     * @return 在字符串匹配给定的正则表达式时，返回 true
     */
    public boolean matches(String regex) {
        String str = new String("www.runoob.com");
        return str.matches(regex);
    }

    /**
     * 检测两个字符串在一个区域内是否相等
     *
     * @param toffset
     * @param other
     * @param ooffset
     * @param len
     * @return
     */
    public boolean regionMatches(int toffset, String other, int ooffset, int len) {
        String str1 = new String("www.runoob.com");
        return str1.regionMatches(toffset, other, ooffset, len);
    }

    /**
     * 检测两个字符串在一个区域内是否相等
     *
     * @param ignoreCase 如果为 true，则比较字符时忽略大小写
     * @param toffset    此字符串中子区域的起始偏移量
     * @param other      字符串参数
     * @param ooffset    字符串参数中子区域的起始偏移量
     * @param len        要比较的字符数
     * @return 如果字符串的指定子区域匹配字符串参数的指定子区域，则返回 true；
     * 否则返回 false。是否完全匹配或考虑大小写取决于 ignoreCase 参数
     */
    public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) {
        String str1 = new String("www.runoob.com");
        return str1.regionMatches(ignoreCase, toffset, other, ooffset, len);
    }

    /**
     * 通过用 newChar 字符替换字符串中出现的所有 oldChar 字符，并返回替换后的新字符串
     *
     * @param oldChar 原字符
     * @param newChar 新字符
     * @return
     */
    public String replace(char oldChar,
                          char newChar) {
        String str = new String("hello");
        return str.replace(oldChar, newChar);
    }

    /**
     * 给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串
     *
     * @param regex       匹配此字符串的正则表达式
     * @param replacement 用来替换每个匹配项的字符串
     * @return
     */
    public String replaceAll(String regex, String replacement) {
        String str = new String("www.google.com");
        return str.replaceAll("(.*)google(.*)", replacement);
    }

    /**
     * 匹配给定的正则表达式来拆分字符串
     *
     * @param regex 正则表达式分隔符
     * @param limit 分割的份数
     * @return
     */
    public String[] split(String regex, int limit) {
        String str = new String("Welcome-to-Runoob");
        return str.split("-");
    }

    /**
     * 检测字符串是否以指定的前缀开始
     *
     * @param prefix  前缀
     * @param toffset 字符串中开始查找的位置
     * @return
     */
    public boolean startsWith(String prefix, int toffset) {
        String str = new String("www.runoob.com");
        return str.startsWith(prefix, toffset);
    }

    public boolean startsWith(String prefix) {
        String str = new String("www.runoob.com");
        return str.startsWith(prefix);
    }

    /**
     * 返回一个新的字符序列，它是此序列的一个子序列
     *
     * @param string
     * @param beginIndex 起始索引（包括）
     * @param endIndex   结束索引（不包括）
     * @return
     */
    public CharSequence subSequence(String string, int beginIndex, int endIndex) {
        return string.subSequence(beginIndex, endIndex);
    }

    /**
     * 方法返回字符串的子字符串。
     *
     * @param beginIndex 起始索引（包括）, 索引从 0 开始
     * @return
     */
    public String substring(String string, int beginIndex) {
        return string.substring(beginIndex);
    }

    /**
     * @param beginIndex
     * @param endIndex   - 结束索引（不包括）
     * @return
     */
    public String substring(String string, int beginIndex, int endIndex) {
        return string.substring(beginIndex,endIndex);
    }

    /**
     * 字符串转换为字符数组
     * @param string
     * @return
     */
    public char[] toCharArray(String string){
        return string.toCharArray();
    }

    /**
     *  方法将字符串转换为小写
     * @return
     */
    public String toLowerCase(String string){
        return string.toLowerCase();
    }
//    public String toLowerCase(Locale locale){
//
//    }

    /**
     * 将字符串小写字符转换为大写。
     * @param string
     * @return
     */
    public String toUpperCase(String string){
        return string.toUpperCase();
    }

}
